home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / 081-090 / amok88 / arexxbox / oberon / test / test2rxif.mod < prev   
Text File  |  1993-11-04  |  9KB  |  380 lines

  1. (*
  2.  * Source generated with ARexxBox 1.11 (Apr 20 1993)
  3.  * which is Copyright (c) 1992,1993 Michael Balzer
  4.  * Oberon-2 Source by hartmut Goebel 1993
  5.  *)
  6.  
  7. MODULE Test2RXIF;
  8.  
  9. (* !ARB: I 727904534 *)
  10.  
  11. IMPORT
  12.   arb:= Test2ARB,
  13.   BT := BasicTypes,
  14.   d  := Dos,
  15.   e  := Exec,
  16.         OberonLib,
  17.   rxh:= ARBRexxHost,
  18.   s  := SYSTEM,
  19.   u  := Utility;
  20.  
  21. TYPE
  22. (* rxd-Strukturen dürfen nur AM ENDE um lokale Variablen erweitert werden! *)
  23.  
  24.   rxdAlias = RECORD (rxh.RXD)
  25.     arg: STRUCT
  26.            global: rxh.ArgBool;
  27.            name: rxh.ArgString;
  28.            command: rxh.ArgString;
  29.     END;
  30.   END;
  31.  
  32.   rxdCmdshell = RECORD (rxh.RXD)
  33.     arg: STRUCT
  34.            open: rxh.ArgBool;
  35.            close: rxh.ArgBool;
  36.     END;
  37.   END;
  38.  
  39.   rxdDisable = RECORD (rxh.RXD)
  40.     arg: STRUCT
  41.            global: rxh.ArgBool;
  42.            names: rxh.ArgStringArray;
  43.     END;
  44.   END;
  45.  
  46.   rxdEnable = RECORD (rxh.RXD)
  47.     arg: STRUCT
  48.            global: rxh.ArgBool;
  49.            names: rxh.ArgStringArray;
  50.     END;
  51.   END;
  52.  
  53.   rxdFault = RECORD (rxh.RXD)
  54.     arg: STRUCT
  55.            var, stem: rxh.ArgString;
  56.            number: rxh.ArgLong;
  57.     END;
  58.     res: STRUCT
  59.            description: rxh.ResString;
  60.     END;
  61.   END;
  62.  
  63.   rxdHelp = RECORD (rxh.RXD)
  64.     arg: STRUCT
  65.            var, stem: rxh.ArgString;
  66.            command: rxh.ArgString;
  67.            prompt: rxh.ArgBool;
  68.     END;
  69.     res: STRUCT
  70.            commanddesc: rxh.ResString;
  71.            commandlist: rxh.ResStringArray;
  72.     END;
  73.   END;
  74.  
  75.   rxdRx = RECORD (rxh.RXD)
  76.     arg: STRUCT
  77.            var, stem: rxh.ArgString;
  78.            console: rxh.ArgBool;
  79.            async: rxh.ArgBool;
  80.            command: rxh.ArgString;
  81.     END;
  82.     res: STRUCT
  83.            rc: rxh.ResLong;
  84.            result: rxh.ResString;
  85.     END;
  86.   END;
  87.  
  88.  
  89. (* !ARB: B 1 ALIAS *)
  90. PROCEDURE Alias * (host: rxh.RexxHost; VAR rxd: rxh.RXDPtr; action: INTEGER);
  91. VAR
  92.   rd: POINTER TO rxdAlias;
  93. BEGIN
  94.    rd := rxd(rxdAlias); (* TypeGuard, stellt sicher, daß auch der richtige *)
  95.            (* RECORD übergeben wurde, wenn rxd = NIL wird nicht geprüft *)
  96.    CASE action OF
  97.    |rxh.init:
  98.        s.ALLOCATE(rd);
  99.        rxd := rd;
  100.        IF rd # NIL THEN
  101.          (* set your DEFAULTS here *)
  102.        END;
  103.  
  104.    |rxh.action:
  105.      (* Insert your CODE here *)
  106.      rd.rc := 0;
  107.  
  108.    |rxh.free:
  109.      (* FREE your local data here *)
  110. (* $IFNOT GarbageCollector *)
  111.      DISPOSE(rd);
  112. (* $END *)
  113.   END;
  114. END Alias;
  115. (* !ARB: E 1 ALIAS *)
  116.  
  117.  
  118. (* !ARB: B 2 CMDSHELL *)
  119. (*
  120.  * Dieses Kommando kann nur von ARexx aus eine CmdShell
  121.  * _ÖFFNEN_, und nur von einer CmdShell aus diese _SCHLIEßEN_.
  122.  *
  123.  * Mit etwas mehr Aufwand (Buchführung über die Hosts) kann man
  124.  * auch eine andere (flexiblere) Lösung finden.
  125.  *
  126.  * ACHTUNG: Buchführung über offene CmdShells ist zwingend
  127.  * notwendig für den CloseDown! Sonst bleiben nach 'Quit' u.U.
  128.  * noch CmdShells offen!
  129.  *)
  130. PROCEDURE runCommandShell(host: rxh.RexxHost): BT.ANY;
  131. VAR
  132.   fh: d.FileHandlePtr;
  133.   rh: rxh.RexxHost;
  134. BEGIN
  135.   (* diese Funktion wird als eigener Prozeß gestartet *)
  136.     
  137.   (* Host, Fenster und CmdShell öffnen *)
  138.   (* rh := arb.SetupARexxHost(NIL); *)
  139.   IF rh # NIL THEN
  140.     fh := d.Open( "CON:////CommandShell/AUTO", d.newFile);
  141.     IF fh # NIL THEN
  142.       rh.CommandShell( fh, fh, "> " );
  143.       d.OldClose( fh );
  144.     END;
  145.     (* arb.CloseDownARexxHost( rh ); *)
  146.   END;
  147.   RETURN NIL;
  148. END runCommandShell;
  149.  
  150.  
  151. PROCEDURE Cmdshell * (host: rxh.RexxHost; VAR rxd: rxh.RXDPtr; action: INTEGER);
  152. VAR
  153.   rd: POINTER TO rxdCmdshell;
  154. BEGIN
  155.    rd := rxd(rxdCmdshell);
  156.  
  157.    CASE action OF
  158.    |rxh.init:
  159.        s.ALLOCATE(rd);
  160.  
  161.    |rxh.action:
  162.      IF rd.arg.close # NIL THEN (* schließen *)
  163.        IF rxh.cmdShell IN host.flags THEN
  164.          (* Flag löschen *)
  165.          EXCL(host.flags,rxh.cmdShell);
  166.        ELSE
  167.          rd.rc := -10;
  168.          rd.rc2 := s.ADR("Not a CommandShell");
  169.        END;
  170.      ELSE (* öffnen (OPEN ist unnötig) *)
  171.        (* CmdShell asynchron als neuen Prozeß starten *)
  172.        (* Design-Probleme!  Wie erzuege ich ein Objekt von gleichen
  173.         * Typ wie der  dynamische Typ von rxh? Mit dem Modul Objects von
  174.         * Fridtjof Siebert ist eine Lösung möglich, wird hier aber nicht
  175.         * diskutiert, weil es noch nicht released wurde.
  176.        Concurrency.NewProcessX(runCommandShell,host,4000,e.exec.thisTask.pri);
  177.        *)
  178.      END;
  179.  
  180.    |rxh.free:
  181. (* $IFNOT GarbageCollector *)
  182.      DISPOSE(rd);
  183. (* $END *)
  184.   END;
  185. END Cmdshell;
  186. (* !ARB: E 2 CMDSHELL *)
  187.  
  188.  
  189. (* !ARB: B 3 DISABLE *)
  190. (*
  191.  * Dieses Kommando sollte besser auch Kommandos lokal zu einem
  192.  * Host beeinflussen können. Vorschlag: Zusätzlicher Switch
  193.  * "GLOBAL/S" (Default wäre damit LOKAL).
  194.  *)
  195. PROCEDURE Disable * (host: rxh.RexxHost; VAR rxd: rxh.RXDPtr; action: INTEGER);
  196. VAR
  197.   rd: POINTER TO rxdDisable;
  198.   sp: rxh.ArgStringArray;
  199.   i, rxc: INTEGER;
  200. BEGIN
  201.    rd := rxd(rxdDisable);
  202.  
  203.    CASE action OF
  204.    |rxh.init:
  205.        s.ALLOCATE(rd);
  206.  
  207.    |rxh.action:
  208.      sp := rd.arg.names;
  209.      IF sp # NIL THEN
  210.        i := 0;
  211.        (* Liste der Namen abarbeiten *)
  212.        WHILE sp[i] # NIL DO
  213.          IF rd.arg.global # 0 THEN
  214.            rxc := host.FindCommand(sp[i]^);
  215.            IF rxc >= 0 THEN
  216.              EXCL(arb.RXCFlags[rxc],rxh.enabled);
  217.            END;
  218.          END;
  219.          INC(i);
  220.        END;
  221.      END;
  222.      rd.rc := 0;
  223.  
  224.    |rxh.free:
  225. (* $IFNOT GarbageCollector *)
  226.      DISPOSE(rd);
  227. (* $END *)
  228.   END;
  229. END Disable;
  230. (* !ARB: E 3 DISABLE *)
  231.  
  232.  
  233. (* !ARB: B 4 ENABLE *)
  234. (*
  235.  * Dieses Kommando sollte besser auch Kommandos lokal zu einem
  236.  * Host beeinflussen können. Vorschlag: Zusätzlicher Switch
  237.  * "GLOBAL/S" (Default wäre damit LOKAL).
  238.  *)
  239. PROCEDURE Enable * (host: rxh.RexxHost; VAR rxd: rxh.RXDPtr; action: INTEGER);
  240. VAR
  241.   rd: POINTER TO rxdEnable;
  242.   sp: rxh.ArgStringArray;
  243.   i, rxc: INTEGER;
  244. BEGIN
  245.    rd := rxd(rxdEnable);
  246.  
  247.    CASE action OF
  248.    |rxh.init:
  249.        s.ALLOCATE(rd);
  250.  
  251.    |rxh.action:
  252.      sp := rd.arg.names;
  253.      IF sp # NIL THEN
  254.        i := 0;
  255.        (* Liste der Namen abarbeiten *)
  256.        WHILE sp[i] # NIL DO
  257.          IF rd.arg.global # 0 THEN
  258.            rxc := host.FindCommand(sp[i]^);
  259.            IF rxc >= 0 THEN
  260.              INCL(arb.RXCFlags[rxc],rxh.enabled);
  261.            END;
  262.          END;
  263.          INC(i);
  264.        END;
  265.      END;
  266.      rd.rc := 0;
  267.  
  268.    |rxh.free:
  269. (* $IFNOT GarbageCollector *)
  270.      DISPOSE(rd);
  271. (* $END *)
  272.   END;
  273. END Enable;
  274. (* !ARB: E 4 ENABLE *)
  275.  
  276.  
  277. (* !ARB: B 5 FAULT *)
  278. PROCEDURE Fault * (host: rxh.RexxHost; VAR rxd: rxh.RXDPtr; action: INTEGER);
  279. VAR
  280.   rd: POINTER TO rxdFault;
  281. BEGIN
  282.    rd := rxd(rxdFault);
  283.  
  284.    CASE action OF
  285.    |rxh.init:
  286.        s.ALLOCATE(rd);
  287.  
  288.    |rxh.action:
  289.      s.ALLOCATE(rd.res.description,256);
  290.      IF rd.res.description # NIL THEN
  291.        IF ~d.Fault(rd.arg.number[0],"DESC", rd.res.description^,
  292.                    LEN(rd.res.description^)) THEN
  293.          rd.rc := -10;
  294.          rd.rc2 := s.ADR("FAULT failed");
  295.        END;
  296.      ELSE
  297.        rd.rc := 10;
  298.        rd.rc2 := rxh.errorNoFreeStore;
  299.      END;
  300.  
  301.    |rxh.free:
  302. (* $IFNOT GarbageCollector *)
  303.      DISPOSE(rd.res.description);
  304.      DISPOSE(rd);
  305. (* $END *)
  306.   END;
  307. END Fault;
  308. (* !ARB: E 5 FAULT *)
  309.  
  310.  
  311. (* !ARB: B 6 HELP *)
  312. PROCEDURE Help * (host: rxh.RexxHost; VAR rxd: rxh.RXDPtr; action: INTEGER);
  313. VAR
  314.   rd: POINTER TO rxdHelp;
  315. BEGIN
  316.    rd := rxd(rxdHelp); (* TypeGuard, stellt sicher, daß auch der richtige *)
  317.            (* RECORD übergeben wurde, wenn rxd = NIL wird nicht geprüft *)
  318.    CASE action OF
  319.    |rxh.init:
  320.        s.ALLOCATE(rd);
  321.        rxd := rd;
  322.        IF rd # NIL THEN
  323.          (* set your DEFAULTS here *)
  324.        END;
  325.  
  326.    |rxh.action:
  327.      (* Insert your CODE here *)
  328.      rd.rc := 0;
  329.  
  330.    |rxh.free:
  331.      (* FREE your local data here *)
  332. (* $IFNOT GarbageCollector *)
  333.      DISPOSE(rd);
  334. (* $END *)
  335.   END;
  336. END Help;
  337. (* !ARB: E 6 HELP *)
  338.  
  339.  
  340. (* !ARB: B 7 RX *)
  341. PROCEDURE Rx * (host: rxh.RexxHost; VAR rxd: rxh.RXDPtr; action: INTEGER);
  342. VAR
  343.   rd: POINTER TO rxdRx;
  344. BEGIN
  345.    rd := rxd(rxdRx); (* TypeGuard, stellt sicher, daß auch der richtige *)
  346.            (* RECORD übergeben wurde, wenn rxd = NIL wird nicht geprüft *)
  347.    CASE action OF
  348.    |rxh.init:
  349.        s.ALLOCATE(rd);
  350.        rxd := rd;
  351.        IF rd # NIL THEN
  352.          (* set your DEFAULTS here *)
  353.        END;
  354.  
  355.    |rxh.action:
  356.      (* Insert your CODE here *)
  357.      rd.rc := 0;
  358.  
  359.    |rxh.free:
  360.      (* FREE your local data here *)
  361. (* $IFNOT GarbageCollector *)
  362.      DISPOSE(rd);
  363. (* $END *)
  364.   END;
  365. END Rx;
  366. (* !ARB: E 7 RX *)
  367.  
  368.  
  369. (* $IFNOT RxAlias *)
  370.  
  371. PROCEDURE ExpandRXCommand*(host: rxh.RexxHost; command: BT.DynString): BT.DynString;
  372. BEGIN
  373.   (* Insert your ALIAS-HANDLER here *)
  374.   RETURN NIL;
  375. END ExpandRXCommand;
  376.  
  377. (* $END *)
  378.  
  379. END Test2RXIF.
  380.